package model

import (
	"database/sql/driver"
	"encoding/json"
	"fmt"
	"yunj/pkg/yunj/util"
)

type Model struct {
}

type MapJson map[string]any

// Value 实现 driver.Valuer 接口
// 将自定义类型的值转换为数据库可以接受的值
func (j MapJson) Value() (driver.Value, error) {
	return json.Marshal(j)
}

// Scan 实现 sql.Scanner 接口
// 将数据库中的值扫描到自定义类型
func (j *MapJson) Scan(value interface{}) error {
	var bytes []byte
	switch v := value.(type) {
	case []byte:
		bytes = v
	case string:
		bytes = []byte(v)
	case map[string]any:
		// 将 v 转换为 SnapType 并赋值给 *j
		*j = MapJson(v)
		return nil
	default:
		return fmt.Errorf("字段转换为model.Json类型失败: %v", value)
	}

	return json.Unmarshal(bytes, j)
}

// 设置属性值
func (j *MapJson) SetAttr(k string, v any) *MapJson {
	(*j)[k] = v
	return j
}

// 获取属性值
func (j *MapJson) GetAttr(k string) any {
	if v, exists := (*j)[k]; exists {
		return v
	}
	return nil
}

// 获取字符串属性值
func (j *MapJson) GetStrAttr(k string) (res string) {
	v := j.GetAttr(k)
	res, _ = util.ToString(v)
	return
}

// 字符串切片json
type StrSliceJson []string

// Value 实现 driver.Valuer 接口
// 将自定义类型的值转换为数据库可以接受的值
func (j StrSliceJson) Value() (driver.Value, error) {
	return json.Marshal(j)
}

// Scan 实现 sql.Scanner 接口
// 将数据库中的值扫描到自定义类型
func (j *StrSliceJson) Scan(value interface{}) error {
	var bytes []byte
	switch v := value.(type) {
	case []byte:
		bytes = v
	case string:
		bytes = []byte(v)
	case []any:
		for _, vv := range v {
			if vvv, ok := vv.(string); ok {
				*j = append(*j, vvv)
			}
		}
		return nil
	case []string:
		// 将 v 转换为 RequestRequireParamsType 并赋值给 *j
		*j = StrSliceJson(v)
		return nil
	default:
		return fmt.Errorf("字段转换为model.StrSliceJson类型失败: %v", value)
	}

	return json.Unmarshal(bytes, j)
}

// uint64切片json
type Uint64SliceJson []uint64

// Value 实现 driver.Valuer 接口
// 将自定义类型的值转换为数据库可以接受的值
func (j Uint64SliceJson) Value() (driver.Value, error) {
	return json.Marshal(j)
}

// Scan 实现 sql.Scanner 接口
// 将数据库中的值扫描到自定义类型
func (j *Uint64SliceJson) Scan(value interface{}) error {
	var bytes []byte
	switch v := value.(type) {
	case []byte:
		bytes = v
	case string:
		bytes = []byte(v)
	case []any:
		for _, vv := range v {
			if vvv, err := util.ToUint64(vv); err == nil {
				*j = append(*j, vvv)
			}
		}
		return nil
	case []uint64:
		// 将 v 转换为 RequestRequireParamsType 并赋值给 *j
		*j = Uint64SliceJson(v)
		return nil
	default:
		return fmt.Errorf("字段转换为model.Uint64SliceJson类型失败: %v", value)
	}

	return json.Unmarshal(bytes, j)
}

// map切片jaon
type MapSliceJson []map[string]any

// Value 实现 driver.Valuer 接口
// 将自定义类型的值转换为数据库可以接受的值
func (j MapSliceJson) Value() (driver.Value, error) {
	return json.Marshal(j)
}

// Scan 实现 sql.Scanner 接口
// 将数据库中的值扫描到自定义类型
func (j *MapSliceJson) Scan(value interface{}) error {
	var bytes []byte
	switch v := value.(type) {
	case []byte:
		bytes = v
	case string:
		bytes = []byte(v)
	case []any:
		for _, vv := range v {
			if vvv, ok := vv.(map[string]any); ok {
				*j = append(*j, vvv)
			}
		}
		return nil
	case []map[string]any:
		// 将 v 转换为 RequestRequireParamsType 并赋值给 *j
		*j = MapSliceJson(v)
		return nil
	default:
		return fmt.Errorf("字段转换为model.MapSliceJson类型失败: %v", value)
	}

	return json.Unmarshal(bytes, j)
}
